C:/Projekte/RAIS/dataaccesslayertest/TableManagementTest.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using NUnit.Framework;
using RAIS.Common.TableManagement;
using RAIS.DataAccessLayer;
using TableTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Table.TableTypeData>;
using TableGroups = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.TableGroup>;
using Tables = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Table>;
using Fields = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field>;
using FieldSizes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field.FieldSizeData>;

namespace RAIS.DataAccessLayerTest
{
        [TestFixture]
        public class TableManagementTest
        {
                TableGroup tableGroup;

                [SetUp]
                public void Init()
                {
            //TestUtilities.TruncateTable("Field");
            //TestUtilities.TruncateTable("Table");
            TestUtilities.DeleteTestTables();

                        this.tableGroup = new TableGroup();
                }
        //*********************************************************************
        #region Properties
                [Test]
                public void TableGroups_Count()
                {
                        // Preparations
                        int expectedCount = 11;

                        // Test 
                        Assert.AreEqual(expectedCount, TableManagement.TableGroups.Count);
                }
                [Test]
                public void TableGroups_AssociatedEquipments()
                {
                        // Preparations
                        int expectedID = 1;
                        string expectedName = "Associated Equipments";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_Authorizations()
                {
                        // Preparations
                        int expectedID = 2;
                        string expectedName = "Authorizations";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_CommonTables()
                {
                        // Preparations
                        int expectedID = 3;
                        string expectedName = "Common Tables";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_Enforcement()
                {
                        // Preparations
                        int expectedID = 4;
                        string expectedName = "Enforcement";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_FacilitiesAndAuthorities()
                {
                        // Preparations
                        int expectedID = 5;
                        string expectedName = "Facilities and Authorities";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_Incidents()
                {
                        // Preparations
                        int expectedID = 6;
                        string expectedName = "Incidents";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_Inspections()
                {
                        // Preparations
                        int expectedID = 7;
                        string expectedName = "Inspections";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_Persons()
                {
                        // Preparations
                        int expectedID = 8;
                        string expectedName = "Persons";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_RadiationGenerators()
                {
                        // Preparations
                        int expectedID = 9;
                        string expectedName = "Radiation Generators";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_SealedSources()
                {
                        // Preparations
                        int expectedID = 10;
                        string expectedName = "Sealed Sources";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                [Test]
                public void TableGroups_UnsealedSources()
                {
                        // Preparations
                        int expectedID = 11;
                        string expectedName = "Unsealed Sources";
                        bool expectedAccepted = true;

                        // Test 
                        this.tableGroup = TableManagement.TableGroups[expectedName];

                        // Checks
                        Assert.AreEqual(expectedID, this.tableGroup.ID);
                        Assert.AreEqual(expectedName, this.tableGroup.Name);
                        Assert.AreEqual(expectedAccepted, this.tableGroup.Accepted);
                }
                #endregion
        //*********************************************************************
        #region Public Methods
                [Test]
                public void SaveTableGroup()
                {
                        // Preparations
                        string name = "Associated Equipments";
                        string errorMessage = "";
                        bool expectedAccepted;
                        TableGroups tableGroups;
                        TableGroup tableGroup;

                        // Save Accsepted = false
                        // Preparations
                        tableGroups = TableManagement.TableGroups;
                        tableGroup = tableGroups[name];
                        expectedAccepted = false;
                        tableGroup.Accepted = expectedAccepted;

                        // Test
                        TableManagement.SaveTableGroup(tableGroup, ref errorMessage);

                        // Checks
                        tableGroups = TableManagement.TableGroups;
                        tableGroup = tableGroups[name];
                        Assert.AreEqual(expectedAccepted, tableGroup.Accepted);

                        // Save Accsepted = true
                        // Preparations
                        tableGroups = TableManagement.TableGroups;
                        tableGroup = tableGroups[name];
                        expectedAccepted = true;
                        tableGroup.Accepted = expectedAccepted;

                        // Test
                        TableManagement.SaveTableGroup(tableGroup, ref errorMessage);

                        //Checks
                        tableGroups = TableManagement.TableGroups;
                        tableGroup = tableGroups[name];
                        Assert.AreEqual(expectedAccepted, tableGroup.Accepted);
                }
                [Test]
                public void AddTable()
                {
                        /*// Preparations
                        string expectedTableName = "Test Table";
                        string expectedGroupName = "Associated Equipments";
                        string expectedTableTypeVisibleName = "Single";
                        Table.TableType expectedTableType = Table.TableType.Single;
                        bool expectedCustomTable = false;
                        string errorMessage = "";
                        bool returnCode;

                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];

                        Table table = new Table();
                        table.Name = expectedTableName;
                        table.TypeText = expectedTableTypeVisibleName;
                        table.CustomTable = expectedCustomTable;

                        // Test
                        returnCode = TableManagement.AddTable(table, tableGroup, ref errorMessage);

                        Assert.IsTrue(returnCode);

                        // Checks
                        Tables tables = TableManagement.GetTablesByTableGroup(tableGroup);
                        Table checkTable = tables[expectedTableName];

                        Assert.AreEqual(expectedTableName, checkTable.Name);
                        Assert.AreEqual(expectedTableType, checkTable.Type);
                        Assert.AreEqual(expectedCustomTable, checkTable.CustomTable);

                        // Restore to the previos state
                        returnCode = TableManagement.RemoveTable(checkTable, ref errorMessage);

                        Assert.IsTrue(returnCode);*/
                }
                [Test]
                [ExpectedException(typeof(System.Collections.Generic.KeyNotFoundException))]
                public void RemoveTable()
                {
                        /*// Preparations
                        string expectedTableName = "Test Table";
                        string expectedGroupName = "Associated Equipments";
                        string expectedTableTypeVisibleName = "Single";
                        string errorMessage = "";
                        bool returnCode;

                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];

                        Table table = new Table();
                        table.Name = expectedTableName;
                        table.TypeText = expectedTableTypeVisibleName;

                        TableManagement.AddTable(table, tableGroup, ref errorMessage);

                        // Test
                        returnCode = TableManagement.RemoveTable(table, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnCode);

                        // Check that field does not exist in table fields
                        // Expected exception System.Collections.Generic.KeyNotFoundException
                        Tables tables = TableManagement.GetTablesByTableGroup(tableGroup);
                        Table checkTable = tables[expectedTableName];*/
                }
                /*[Test]
                public void GetTablesByTableGroup()
                {
                        // Preparations
                        int expectedCount = 3;
                        string[] expectedTableNames = { "Test Table 1", "Test Table 2", "Test Table 3" };
                        string expectedGroupName = "Associated Equipments";
                        string[] expectedTableTypeVisibleNames = { "Single", "With History", "Authorization" };
                        Table.TableType[] expectedTableTypes = {
                                  Table.TableType.Single
                                , Table.TableType.WithHistory
                                , Table.TableType.Authorization
                        };
                        string errorMessage = "";
                        bool returnCode;

                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];

                        Table[] tables = new Table[expectedCount];
                        for (int i = 0; i < expectedCount; i++ )
                        {
                                tables[i] = new Table();
                                tables[i].Name = expectedTableNames[i];
                                tables[i].TypeText = expectedTableTypeVisibleNames[i];
                                TableManagement.AddTable(tables[i], tableGroup, ref errorMessage);
                        }

                        // Test
                        Tables checkedTabels = TableManagement.GetTablesByTableGroup(tableGroup);

                        // Checks
                        //Assert.AreEqual(expectedCount, checkedTabels.Count);
                        for (int i = 0; i < expectedCount; i++)
                        {
                                Table checkTable = checkedTabels[expectedTableNames[i]];
                                Assert.AreEqual(expectedTableTypes[i], checkTable.Type);
                        }

                        // Restore to the previos state
                        for (int i = 0; i < expectedCount; i++)
                        {
                                returnCode = TableManagement.RemoveTable(checkedTabels[expectedTableNames[i]], ref errorMessage);
                        }
                }*/
                /*[Test]
                public void GetCustomTablesByTableGroup()
                {
                        // Preparations
                        int expectedCount = 3;
                        string[] expectedTableNames = { "Test Table 1", "Test Table 2", "Test Table 3" };
                        string expectedGroupName = "Associated Equipments";
                        string[] expectedTableTypeVisibleNames = { "Single", "With History", "Authorization" };
                        Table.TableType[] expectedTableTypes = {
                                  Table.TableType.Single
                                , Table.TableType.WithHistory
                                , Table.TableType.Authorization
                        };
                        bool[] expectedCustomTables = {true, true, false };
                        string errorMessage = "";
                        bool returnCode;

                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];

                        Table[] tables = new Table[expectedCount];
                        for (int i = 0; i < expectedCount; i++)
                        {
                                tables[i] = new Table();
                                tables[i].Name = expectedTableNames[i];
                                tables[i].TypeText = expectedTableTypeVisibleNames[i];
                                tables[i].CustomTable = expectedCustomTables[i];
                                TableManagement.AddTable(tables[i], tableGroup, ref errorMessage);
                        }

                        // Test
                        Tables checkedTabels = TableManagement.GetCustomTablesByTableGroup(tableGroup);

                        // Checks
                        Assert.AreEqual(expectedCount - 1, checkedTabels.Count);
                        for (int i = 0; i < expectedCount - 1; i++)
                        {
                                Table checkTable = checkedTabels[expectedTableNames[i]];
                                Assert.AreEqual(expectedTableTypes[i], checkTable.Type);
                        }

                        // Restore to the previos state
                        checkedTabels = TableManagement.GetTablesByTableGroup(tableGroup);
                        for (int i = 0; i < expectedCount; i++)
                        {
                                returnCode = TableManagement.RemoveTable(checkedTabels[expectedTableNames[i]], ref errorMessage);
                        }
                }*/
                [Test]
                public void AddField()
                {
                        /*// Preparations
                        // Add Table
                        string expectedTableName = "Test Table";
                        string expectedRelatedTableName = "Related Table";
                        string expectedGroupName = "Associated Equipments";
                        string expectedTableTypeVisibleName = "Single";
            bool expectedCustomTable = true;
            Table.TableType expectedTableType = Table.TableType.Single;
                        string errorMessage = "";
                        bool returnCode;
                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];
                        Table table = new Table();
                        table.Name = expectedTableName;
                        table.TypeText = expectedTableTypeVisibleName;
            table.CustomTable = expectedCustomTable;
                        TableManagement.AddTable(table, tableGroup, ref errorMessage);
                        Table relatedTable = new Table();
                        relatedTable.Name = expectedRelatedTableName;
                        relatedTable.TypeText = expectedTableTypeVisibleName;
            relatedTable.CustomTable = expectedCustomTable;
            TableManagement.AddTable(relatedTable, tableGroup, ref errorMessage);

                        string expectedFieldName = "Test Field";
                        string expectedLocalLanguageFieldName = "Òåñòîâîå ïîëå";
                        string expectedFieldPurpose = "Field Purpose";
                        string expectedLocalLanguageFieldPurpose = "Íàçíà÷åíèå ïîëÿ";
                        string expectedFieldTypeText = "Text";
                        Field.FieldType expectedFieldType = Field.FieldType.Text;
            string expectedFieldSizeText = "Large (below 256 chars)";
            Field.FieldSize expectedFieldSize = Field.FieldSize.Large;
            string expectedNecessityTypeVisibleName = "Required";
            Field.NecessityType expectedNecessityType = Field.NecessityType.Required;
                        int expectedOrder = 10;
                        bool expectedIsNameField = true;
                        bool expectedSystemField = true;
                        bool expectedVisibleOnForms = true;
                        bool expectedUniqueValue = true;
                        bool expectedNeedsTranslation = true;
                        bool expectedMultiline = true;

                        Field field = new Field();
                        field.Name = expectedFieldName;
                        field.FieldPurpose = expectedFieldPurpose;
                        field.LocalLanguageFieldName = expectedLocalLanguageFieldName;
                        field.LocalLanguageFieldPurpose = expectedLocalLanguageFieldPurpose;
                        field.TypeText = expectedFieldTypeText;
            field.SizeText = expectedFieldSizeText;
                        field.NecessityText = expectedNecessityTypeVisibleName;
                        field.Order = expectedOrder;
                        field.IsNameField = expectedIsNameField;
                        field.SystemField = expectedSystemField;
                        field.VisibleOnForms = expectedVisibleOnForms;
                        field.UniqueValue = expectedUniqueValue;
                        field.NeedsTranslation = expectedNeedsTranslation;
                        field.Multiline = expectedMultiline;
                        field.RelatedTable = relatedTable;

                        // Test
                        returnCode = TableManagement.AddField(table, field, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnCode);

                        Fields fields = TableManagement.GetFieldsByTable(table);
                        Field checkField = fields[expectedFieldName];

                        Assert.AreEqual(expectedFieldPurpose, checkField.FieldPurpose);
                        Assert.AreEqual(expectedLocalLanguageFieldName, checkField.LocalLanguageFieldName);
                        Assert.AreEqual(expectedLocalLanguageFieldPurpose, checkField.LocalLanguageFieldPurpose);
                        Assert.AreEqual(expectedFieldType, checkField.Type);
            Assert.AreEqual(expectedFieldSize, checkField.Size);
            Assert.AreEqual(expectedNecessityType, checkField.Necessity);
                        Assert.AreEqual(expectedOrder, checkField.Order);
                        Assert.AreEqual(expectedIsNameField, checkField.IsNameField);
                        Assert.AreEqual(expectedSystemField, checkField.SystemField);
                        Assert.AreEqual(expectedVisibleOnForms, checkField.VisibleOnForms);
                        Assert.AreEqual(expectedUniqueValue, checkField.UniqueValue);
                        Assert.AreEqual(expectedNeedsTranslation, checkField.NeedsTranslation);
                        Assert.AreEqual(expectedMultiline, checkField.Multiline);
                        Assert.AreEqual(expectedRelatedTableName, checkField.RelatedTable.Name);
                        Assert.AreEqual(expectedTableType, checkField.RelatedTable.Type);

                        // Restore to the previos state
                        TableManagement.RemoveField(checkField, ref errorMessage);
                        TableManagement.RemoveTable(table, ref errorMessage);
                        TableManagement.RemoveTable(relatedTable, ref errorMessage);*/
                }
                /*[Test]
                public void SaveField()
                {
                        // Preparations
                        // Add Table
                        string expectedTableName = "Test Table";
                        string expectedGroupName = "Associated Equipments";
                        string expectedTableTypeVisibleName = "Single";
                        string errorMessage = "";
                        bool returnCode;
                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];
                        Table table = new Table();
                        table.Name = expectedTableName;
                        table.TypeText = expectedTableTypeVisibleName;
                        TableManagement.AddTable(table, tableGroup, ref errorMessage);

                        string initFieldName = "Test Field";
                        string initLocalLanguageFieldName = "Òåñòîâîå ïîëå";
                        string initFieldPurpose = "Field Purpose";
                        string initLocalLanguageFieldPurpose = "Íàçíà÷åíèå ïîëÿ";
                        string initFieldTypeText = "Text";
                        string initNecessityTypeVisibleName = "Required";
                        int initOrder = 10;
                        bool initIsNameField = true;
                        bool initSystemField = true;
                        bool initVisibleOnForms = true;
                        bool initUniqueValue = true;
                        bool initNeedsTranslation = true;
                        bool initMultiline = true;

                        Field field = new Field();
                        field.Name = initFieldName;
                        field.FieldPurpose = initFieldPurpose;
                        field.LocalLanguageFieldName = initLocalLanguageFieldName;
                        field.LocalLanguageFieldPurpose = initLocalLanguageFieldPurpose;
                        field.TypeText = initFieldTypeText;
                        field.NecessityText = initNecessityTypeVisibleName;
                        field.Order = initOrder;
                        field.IsNameField = initIsNameField;
                        field.SystemField = initSystemField;
                        field.VisibleOnForms = initVisibleOnForms;
                        field.UniqueValue = initUniqueValue;
                        field.NeedsTranslation = initNeedsTranslation;
                        field.Multiline = initMultiline;
            TableManagement.AddField(table, field, ref errorMessage);

                        string expectedFieldName = "Updated Test Field";
                        string expectedLocalLanguageFieldName = "Èçìåíåííîå òåñòîâîå ïîëå";
                        string expectedFieldPurpose = "Updated Field Purpose";
                        string expectedLocalLanguageFieldPurpose = "Èçìåíåííîå íàçíà÷åíèå ïîëÿ";
                        string expectedFieldTypeText = "Date";
                        Field.FieldType expectedFieldType = Field.FieldType.Date;
                        Field.NecessityType expectedNecessityType = Field.NecessityType.Suggested;
                        string expectedNecessityTypeVisibleName = "Suggested";
                        int expectedOrder = 5;
                        bool expectedIsNameField = false;
                        bool expectedSystemField = false;
                        bool expectedVisibleOnForms = false;
                        bool expectedUniqueValue = false;
                        bool expectedNeedsTranslation = false;
                        bool expectedMultiline = false;

                        // Set new values
                        field.Name = expectedFieldName;
                        field.FieldPurpose = expectedFieldPurpose;
                        field.LocalLanguageFieldName = expectedLocalLanguageFieldName;
                        field.LocalLanguageFieldPurpose = expectedLocalLanguageFieldPurpose;
                        field.TypeText = expectedFieldTypeText;
                        field.NecessityText = expectedNecessityTypeVisibleName;
                        field.Order = expectedOrder;
                        field.IsNameField = expectedIsNameField;
                        field.SystemField = expectedSystemField;
                        field.VisibleOnForms = expectedVisibleOnForms;
                        field.UniqueValue = expectedUniqueValue;
                        field.NeedsTranslation = expectedNeedsTranslation;
                        field.Multiline = expectedMultiline;

                        // Test
                        returnCode = TableManagement.SaveField(field, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnCode);

                        Fields fields = TableManagement.GetFieldsByTable(table);
                        Field checkField = fields[expectedFieldName];

                        Assert.AreEqual(expectedFieldPurpose, checkField.FieldPurpose);
                        Assert.AreEqual(expectedLocalLanguageFieldName, checkField.LocalLanguageFieldName);
                        Assert.AreEqual(expectedLocalLanguageFieldPurpose, checkField.LocalLanguageFieldPurpose);
                        Assert.AreEqual(expectedFieldType, checkField.Type);
                        Assert.AreEqual(expectedNecessityType, checkField.Necessity);
                        Assert.AreEqual(expectedOrder, checkField.Order);
                        Assert.AreEqual(expectedIsNameField, checkField.IsNameField);
                        Assert.AreEqual(expectedSystemField, checkField.SystemField);
                        Assert.AreEqual(expectedVisibleOnForms, checkField.VisibleOnForms);
                        Assert.AreEqual(expectedUniqueValue, checkField.UniqueValue);
                        Assert.AreEqual(expectedNeedsTranslation, checkField.NeedsTranslation);
                        Assert.AreEqual(expectedMultiline, checkField.Multiline);

                        // Restore to the previos state
                        TableManagement.RemoveField(checkField, ref errorMessage);
                        TableManagement.RemoveTable(table, ref errorMessage);
                }
                [Test]
                [ExpectedException(typeof(System.Collections.Generic.KeyNotFoundException))]
                public void RemoveField()
                {
                        // Preparations
                        // Add Table
                        string expectedTableName = "Test Table";
                        string expectedGroupName = "Associated Equipments";
                        string expectedTableTypeVisibleName = "Single";
                        string errorMessage = "";
                        bool returnCode;
                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];
                        Table table = new Table();
                        table.Name = expectedTableName;
                        table.TypeText = expectedTableTypeVisibleName;
                        TableManagement.AddTable(table, tableGroup, ref errorMessage);

                        string expectedFieldName = "Test Field";
                        string expectedLocalLanguageFieldName = "Òåñòîâîå ïîëå";
                        string expectedFieldPurpose = "Field Purpose";
                        string expectedLocalLanguageFieldPurpose = "Íàçíà÷åíèå ïîëÿ";
                        string expectedFieldTypeText = "Text";
            string expectedFieldSizeText = "Large (below 256 chars)";
            string expectedNecessityTypeVisibleName = "Required";
                        int expectedOrder = 10;
                        bool expectedIsNameField = true;
                        bool expectedSystemField = true;
                        bool expectedVisibleOnForms = true;
                        bool expectedUniqueValue = true;
                        bool expectedNeedsTranslation = true;
                        bool expectedMultiline = true;

                        Field field = new Field();
                        field.Name = expectedFieldName;
                        field.FieldPurpose = expectedFieldPurpose;
                        field.LocalLanguageFieldName = expectedLocalLanguageFieldName;
                        field.LocalLanguageFieldPurpose = expectedLocalLanguageFieldPurpose;
                        field.TypeText = expectedFieldTypeText;
            field.SizeText = expectedFieldSizeText;
            field.NecessityText = expectedNecessityTypeVisibleName;
                        field.Order = expectedOrder;
                        field.IsNameField = expectedIsNameField;
                        field.SystemField = expectedSystemField;
                        field.VisibleOnForms = expectedVisibleOnForms;
                        field.UniqueValue = expectedUniqueValue;
                        field.NeedsTranslation = expectedNeedsTranslation;
                        field.Multiline = expectedMultiline;
            TableManagement.AddField(table, field, ref errorMessage);

                        // Test
                        returnCode = TableManagement.RemoveField(field, ref errorMessage);

                        // Checks
                        Assert.IsTrue(returnCode);

                        // Check that field does not exist in table fields
                        // Expected exception System.Collections.Generic.KeyNotFoundException
                        Fields fields = TableManagement.GetFieldsByTable(table);
                        try
                        {
                                Field checkField = fields[expectedFieldName];
                        }
                        finally
                        {
                                // Restore to the previos state
                                TableManagement.RemoveTable(table, ref errorMessage);
                        }
                }
                [Test]
                public void GetFieldsByTable()
                {
                        // Preparations
                        // Add Table
                        string expectedTableName = "Test Table";
                        string expectedGroupName = "Associated Equipments";
                        string expectedTableTypeVisibleName = "Single";
                        string errorMessage = "";
                        TableGroups tableGroups = TableManagement.TableGroups;
                        TableGroup tableGroup = tableGroups[expectedGroupName];
                        Table table = new Table();
                        table.Name = expectedTableName;
                        table.TypeText = expectedTableTypeVisibleName;
                        TableManagement.AddTable(table, tableGroup, ref errorMessage);

                        string[] expectedFieldNames = { "Test Field 1", "Test Field 2", "Test Field 3" };
                        string[] expectedLocalLanguageFieldNames = { "Òåñòîâîå ïîëå 1", "Òåñòîâîå ïîëå 2", "Òåñòîâîå ïîëå 3" };
                        string[] expectedFieldPurposes = { "Field Purpose 1", "Field Purpose 2", "Field Purpose 3" };
                        string[] expectedLocalLanguageFieldPurposes = { "Íàçíà÷åíèå ïîëÿ 1", "Íàçíà÷åíèå ïîëÿ 2", "Íàçíà÷åíèå ïîëÿ 3" };
                        string[] expectedFieldTypesText = { "Text", "Date", "Lookup Plus Integer Value" };
                        Field.FieldType[] expectedFieldTypes = { Field.FieldType.Text, Field.FieldType.Date, Field.FieldType.LookupPlusIntegerValue };
                        Field.NecessityType[] expectedNecessityTypes = { Field.NecessityType.Required, Field.NecessityType.NotRequired, Field.NecessityType.Suggested };
                        string[] expectedNecessityTypeVisibleNames = { "Required", "Not Required", "Suggested" };
                        int[] expectedOrders = { 5, 10, 15 };
                        bool[] expectedIsNameFields = { true, false, true };
                        bool[] expectedSystemFields = { true, false, true };
                        bool[] expectedVisibleOnForms = { true, false, true };
                        bool[] expectedUniqueValues = { true, false, true };
                        bool[] expectedNeedsTranslations = { true, false, true };
                        bool[] expectedMultilines = { true, false, true };

                        int expectedCount = expectedFieldNames.Length;
                        Field[] fields = new Field[expectedCount];
                        for (int i = 0; i < expectedCount; i++)
                        {
                                fields[i] = new Field();
                                fields[i].Name = expectedFieldNames[i];
                                fields[i].FieldPurpose = expectedFieldPurposes[i];
                                fields[i].LocalLanguageFieldName = expectedLocalLanguageFieldNames[i];
                                fields[i].LocalLanguageFieldPurpose = expectedLocalLanguageFieldPurposes[i];
                                fields[i].TypeText = expectedFieldTypesText[i];
                                fields[i].NecessityText = expectedNecessityTypeVisibleNames[i];
                                fields[i].Order = expectedOrders[i];
                                fields[i].IsNameField = expectedIsNameFields[i];
                                fields[i].SystemField = expectedSystemFields[i];
                                fields[i].VisibleOnForms = expectedVisibleOnForms[i];
                                fields[i].UniqueValue = expectedUniqueValues[i];
                                fields[i].NeedsTranslation = expectedNeedsTranslations[i];
                                fields[i].Multiline = expectedMultilines[i];

                TableManagement.AddField(table, fields[i], ref errorMessage);
                        }

                        // Test
                        Fields checkFields = TableManagement.GetFieldsByTable(table);

                        // Checks
                        Assert.AreEqual(expectedCount, checkFields.Count);

                        for (int i = 0; i < expectedCount; i++)
                        {
                                Field checkField = checkFields[expectedFieldNames[i]];
                                Assert.AreEqual(expectedFieldPurposes[i], checkField.FieldPurpose);
                                Assert.AreEqual(expectedLocalLanguageFieldNames[i], checkField.LocalLanguageFieldName);
                                Assert.AreEqual(expectedLocalLanguageFieldPurposes[i], checkField.LocalLanguageFieldPurpose);
                                Assert.AreEqual(expectedFieldTypes[i], checkField.Type);
                                Assert.AreEqual(expectedNecessityTypes[i], checkField.Necessity);
                                Assert.AreEqual(expectedOrders[i], checkField.Order);
                                Assert.AreEqual(expectedIsNameFields[i], checkField.IsNameField);
                                Assert.AreEqual(expectedSystemFields[i], checkField.SystemField);
                                Assert.AreEqual(expectedVisibleOnForms[i], checkField.VisibleOnForms);
                                Assert.AreEqual(expectedUniqueValues[i], checkField.UniqueValue);
                                Assert.AreEqual(expectedNeedsTranslations[i], checkField.NeedsTranslation);
                                Assert.AreEqual(expectedMultilines[i], checkField.Multiline);
                        }

                        // Restore to the previos state
                        for (int i = 0; i < expectedCount; i++)
                        {
                            TableManagement.RemoveField(checkFields[expectedFieldNames[i]], ref errorMessage);
                        }
                        TableManagement.RemoveTable(table, ref errorMessage);
                }*/
                [Test]
                public void GetFieldSizesByFieldType_DateTypeSizesCount()
                {
                        // Preparations
                        int expectedCount = 0;
                        Field.FieldType expectedFieldType = Field.FieldType.Date;

                        // Test
                        FieldSizes fieldSizes = TableManagement.GetFieldSizesByFieldType(expectedFieldType);

                        // Checks
                        Assert.AreEqual(expectedCount, fieldSizes.Count);
                }
                [Test]
                public void GetFieldSizesByFieldType_LookupPlusIntegerValueTypeSizesCount()
                {
                        // Preparations
                        int expectedCount = 0;
                        Field.FieldType expectedFieldType = Field.FieldType.LookupPlusIntegerValue;

                        // Test
                        FieldSizes fieldSizes = TableManagement.GetFieldSizesByFieldType(expectedFieldType);

                        // Checks
                        Assert.AreEqual(expectedCount, fieldSizes.Count);
                }
                [Test]
                public void GetFieldSizesByFieldType_LookupPlusScientificValueTypeSizesCount()
                {
                        // Preparations
                        int expectedCount = 0;
                        Field.FieldType expectedFieldType = Field.FieldType.LookupPlusScientificValue;

                        // Test
                        FieldSizes fieldSizes = TableManagement.GetFieldSizesByFieldType(expectedFieldType);

                        // Checks
                        Assert.AreEqual(expectedCount, fieldSizes.Count);
                }
                [Test]
                public void GetFieldSizesByFieldType_MultipleLookupTypeSizesCount()
                {
                        // Preparations
                        int expectedCount = 0;
                        Field.FieldType expectedFieldType = Field.FieldType.MultipleLookup;

                        // Test
                        FieldSizes fieldSizes = TableManagement.GetFieldSizesByFieldType(expectedFieldType);

                        // Checks
                        Assert.AreEqual(expectedCount, fieldSizes.Count);
                }
                [Test]
                public void GetFieldSizesByFieldType_NumericTypeSizesCount()
                {
                        // Preparations
                        int expectedCount = 5;
                        Field.FieldType expectedFieldType = Field.FieldType.Numeric;

                        // Test
                        FieldSizes fieldSizes = TableManagement.GetFieldSizesByFieldType(expectedFieldType);

                        // Checks
                        Assert.AreEqual(expectedCount, fieldSizes.Count);
                }
                [Test]
                public void GetFieldSizesByFieldType_SingleLookupTypeSizesCount()
                {
                        // Preparations
                        int expectedCount = 0;
                        Field.FieldType expectedFieldType = Field.FieldType.SingleLookup;

                        // Test
                        FieldSizes fieldSizes = TableManagement.GetFieldSizesByFieldType(expectedFieldType);

                        // Checks
                        Assert.AreEqual(expectedCount, fieldSizes.Count);
                }
                [Test]
                public void GetFieldSizesByFieldType_TextTypeSizesCount()
                {
                        // Preparations
                        int expectedCount = 4;
                        Field.FieldType expectedFieldType = Field.FieldType.Text;

                        // Test
                        FieldSizes fieldSizes = TableManagement.GetFieldSizesByFieldType(expectedFieldType);

                        // Checks
                        Assert.AreEqual(expectedCount, fieldSizes.Count);
                }
                [Test]
                public void GetFieldSizesByFieldType_Large()
                {
                        // Preparations
                        int expectedID = 1;
                        Field.FieldSize expectedSize = Field.FieldSize.Large;
                        string expectedVisibleName = "Large (below 256 chars)";
                        Field.FieldType expectedFieldType = Field.FieldType.Text;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_Medium()
                {
                        // Preparations
                        int expectedID = 2;
                        Field.FieldSize expectedSize = Field.FieldSize.Medium;
                        string expectedVisibleName = "Medium (below 128 chars)";
                        Field.FieldType expectedFieldType = Field.FieldType.Text;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_Memo()
                {
                        // Preparations
                        int expectedID = 3;
                        Field.FieldSize expectedSize = Field.FieldSize.Memo;
                        string expectedVisibleName = "Memo (more then 255 chars)";
                        Field.FieldType expectedFieldType = Field.FieldType.Text;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_Small()
                {
                        // Preparations
                        int expectedID = 4;
                        Field.FieldSize expectedSize = Field.FieldSize.Small;
                        string expectedVisibleName = "Small (below 50 chars)";
                        Field.FieldType expectedFieldType = Field.FieldType.Text;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_Integer()
                {
                        // Preparations
                        int expectedID = 5;
                        Field.FieldSize expectedSize = Field.FieldSize.Integer;
                        string expectedVisibleName = "Integer (-2; -1; 0; 1; 2...)";
                        Field.FieldType expectedFieldType = Field.FieldType.Numeric;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_Rational()
                {
                        // Preparations
                        int expectedID = 6;
                        Field.FieldSize expectedSize = Field.FieldSize.Rational;
                        string expectedVisibleName = "Rational (-2.5; 0.0; 2.5)";
                        Field.FieldType expectedFieldType = Field.FieldType.Numeric;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_Scientific()
                {
                        // Preparations
                        int expectedID = 7;
                        Field.FieldSize expectedSize = Field.FieldSize.Scientific;
                        string expectedVisibleName = "Scientific Number";
                        Field.FieldType expectedFieldType = Field.FieldType.Numeric;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_TimeInterval()
                {
                        // Preparations
                        int expectedID = 8;
                        Field.FieldSize expectedSize = Field.FieldSize.TimeInterval;
                        string expectedVisibleName = "Time Interval";
                        Field.FieldType expectedFieldType = Field.FieldType.Numeric;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                [Test]
                public void GetFieldSizesByFieldType_Year()
                {
                        // Preparations
                        int expectedID = 9;
                        Field.FieldSize expectedSize = Field.FieldSize.Year;
                        string expectedVisibleName = "Year";
                        Field.FieldType expectedFieldType = Field.FieldType.Numeric;

                        // Test
                        Field.FieldSizeData fieldSizeData = TableManagement.GetFieldSizesByFieldType(expectedFieldType)[expectedVisibleName];

                        // Checks
                        Assert.AreEqual(expectedID, fieldSizeData.ID);
                        Assert.AreEqual(expectedSize, fieldSizeData.Type);
                        Assert.AreEqual(expectedVisibleName, fieldSizeData.VisibleName);
                        Assert.AreEqual(expectedFieldType, fieldSizeData.FieldType);
                }
                #endregion
        [TearDown]
        public void Finally()
        {
            //TestUtilities.TruncateTable("Field");
            //TestUtilities.TruncateTable("Table");
            TestUtilities.DeleteTestTables();
        }
    }
}